const http = require('../../../utils/http.js');
const tools = require('../../../utils/tools.js');

Page({
  data: {
    // 学籍基础信息数据对象
    ck_academic_info: {
      education_level: '',      // 文化程度，存储对应下拉框选项的 id
      diploma_number: '',       // 毕业证书编号
      graduation_type: '',      // 毕业类型（id）
      graduation_school: '',    // 毕业学校（id）
      graduation_date: '',      // 毕业日期 YYYY-MM-DD
      job_category: '',         // 职业类别（id）
      is_working: '否',           // 是否参加工作，存储 "是" 或 "否"
      work_location: '',        // 工作单位所在地（仅工作状态为“是”时填写）
      work_name: '',            // 工作单位名称（仅工作状态为“是”时填写）
      work_start_date: ''       // 参加工作日期（仅工作状态为“是”时填写）
    },
    // 下拉选项及下标
    educationOptions: [],
    educationIndex: null,
    graduationTypeOptions: [],
    graduationTypeIndex: null,
    schoolOptions: [],
    schoolIndex: null,
    occupationOptions: [],
    occupationIndex: null,
    workingOptions: ['否', '是'], // 是否参加工作
    workingIndex: 0,             // 默认“不参加工作”

    // 展示工作相关信息的字段
    isShowWorkingInfo: false,

    // 语音相关
    recordedText: null,
    recording: false,
    recordFilePath: '',
    buttonText: '开始录音'
  },

  onLoad() {
    // 加载各个下拉框选项数据
    const eduPromise = tools.fetchOptions('/chengkao/CKeducation/all', 'educationOptions', this);
    const gradTypePromise = tools.fetchOptions('/chengkao/graduationType/all', 'graduationTypeOptions', this);
    const schoolPromise = tools.fetchOptions('/chengkao/CKschool/all', 'schoolOptions', this);
    const occuPromise = tools.fetchOptions('/chengkao/CKoccupation/all', 'occupationOptions', this);
    
    Promise.all([eduPromise, gradTypePromise, schoolPromise, occuPromise])
      .then(() => {
        // 加载本地存储的学籍信息（如有）
        const storedInfo = wx.getStorageSync('ck_academic_info');
        if (storedInfo) {
          this.setData({ ck_academic_info: storedInfo });
          // 根据存储的各字段 id 查找下标，更新下拉框默认选中
          this.updateIndexById(storedInfo);
          this.updateWorkingShowInfo(storedInfo.is_working)
        }
      })
      .catch(err => {
        console.error('加载选项数据失败:', err);
      });
  },

  updateIndexById(data){
    // 根据存储的各字段 id 查找下标，更新下拉框默认选中
    this.setData({
      educationIndex: tools.findIndexById(this.data.educationOptions, data.education_level),
      graduationTypeIndex: tools.findIndexById(this.data.graduationTypeOptions, data.graduation_type),
      schoolIndex: tools.findIndexById(this.data.schoolOptions, data.graduation_school),
      occupationIndex: tools.findIndexById(this.data.occupationOptions, data.job_category),
      workingIndex: data.is_working === "是" ? 1 : 0
    });
  },
  updateWorkingShowInfo(name){
      console.log("name" + name)
    // 根据字段值选择是否重置选项，以及是否展示相关信息
    if(name === '是'){
      this.setData({
        isShowWorkingInfo:true
      })
    }else{
      this.setData({
        isShowWorkingInfo:false,
        'ck_academic_info.work_location':'',
        'ck_academic_info.work_name':'',
        'ck_academic_info.work_start_date':'',
      })
    }
  },

  // 输入框回调
  handleInput(e) {
    const { field } = e.currentTarget.dataset;
    this.setData({ [`ck_academic_info.${field}`]: e.detail.value });
  },

  // 下拉选择回调：更新相应字段下标和值（选项的 id）
  handlePickerChange(e) {
    const { field } = e.currentTarget.dataset;
    const index = e.detail.value;
    let valueId = '';
    // 根据 field 区分不同选项来源
    if (field === 'education_level') {
      valueId = this.data.educationOptions[index].id;
      this.setData({ educationIndex: index });
    } else if (field === 'graduation_type') {
      valueId = this.data.graduationTypeOptions[index].id;
      this.setData({ graduationTypeIndex: index });
    } else if (field === 'graduation_school') {
      valueId = this.data.schoolOptions[index].id;
      this.setData({ schoolIndex: index });
    } else if (field === 'job_category') {
      valueId = this.data.occupationOptions[index].id;
      this.setData({ occupationIndex: index });
    } 
    // 更新对应字段值
    this.setData({ [`ck_academic_info.${field}`]: valueId });
  },

  // 日期选择回调
  handleDateChange(e) {
    const { field } = e.currentTarget.dataset;
    this.setData({ [`ck_academic_info.${field}`]: e.detail.value });
  },

  // “是否参加工作”下拉框改变时，动态显示或隐藏工作相关输入框
  handleWorkStatusChange(e) {
    const index = e.detail.value;
    const workingVal = this.data.workingOptions[index];
    this.setData({
      workingIndex: index,
      'ck_academic_info.is_working': workingVal
    });
    this.updateWorkingShowInfo(workingVal)
  },

  // 提交学籍信息，并跳转到考试报考信息填写页面（chengkao_page3）
  handleSubmit() {
    // 进行重复校验
    const fieldsToCheck = [
      'education_level',   // 文化程度
      'diploma_number',    // 毕业证书编号
      'graduation_type',   // 毕业类型
      'graduation_school', // 毕业学校
      'graduation_date',   // 毕业日期
      'job_category',      // 职业类别
      'is_working',        // 是否参加工作
      'work_location',     // 工作单位所在地
      'work_name',         // 工作单位名称
      'work_start_date'    // 参加工作日期
    ];
    const storedInfo = wx.getStorageSync('ck_academic_info');
    const data = this.data.ck_academic_info;
    if(tools.checkDataChanged(data,storedInfo,fieldsToCheck)){
      const idNumber = wx.getStorageSync('base_candidate_info').id_number;
      const postData = {
        idNumber : idNumber, 
        culturalLevelId: data.education_level,             // 文化程度，对应 ck_education(id)
        graduationCertificateNo: data.diploma_number,      // 毕业证书编号
        graduationTypeId: data.graduation_type,              // 毕业类型
        schoolId: data.graduation_school,                    // 毕业学校
        graduationDate: data.graduation_date,                // 毕业日期（格式：yyyy-MM-dd）
        occupationId: data.job_category,                     // 职业类别
        isEmployed: data.is_working,                         // 是否参加工作 ("是" 或 "否")
        workLocation: data.work_location,                    // 工作单位所在地
        workUnitName: data.work_name,                        // 工作单位名称
        employmentDate: data.work_start_date                 // 参加工作日期（格式：yyyy-MM-dd）
      };
      http.post("/chengkao/CKregistration/upsert", postData).then(res => {
        if (res.data.code === 200) {
          wx.setStorageSync('ck_academic_info', this.data.ck_academic_info);
          wx.showToast({ title: '学籍信息更新成功', duration: 2000 });
          wx.navigateTo({ url: '/pages/chengkao/chengkao_page3/chengkao_page3' });
        }
      }).catch(err => {
        console.error('学籍信息更新失败:', err);
        wx.showToast({ title: '学籍信息更新失败', icon: 'none', duration: 2000 });
      });
    }else{
      wx.navigateTo({ url: '/pages/chengkao/chengkao_page3/chengkao_page3' });
    }
  },

  // 语音功能
  // 录音按键
  toggleRecording() {
    if (this.data.recording) {
      this.setData({ recording: false });
      const recorderManager = wx.getRecorderManager();
      recorderManager.stop();
      recorderManager.onStop((res) => {
        wx.setStorageSync('recordPath', res.tempFilePath);
        this.setData({ recordFilePath: res.tempFilePath });
        this.setData({ buttonText: '开始录音' });
      });
    } else {
        tools.checkRecordPermission().then(() => {
        this.setData({ recording: true });
        const recorderManager = wx.getRecorderManager();
        recorderManager.start({
          format: 'wav',
          duration: 60000,
          sampleRate: 44100,
          numberOfChannels: 1,
          encodeBitRate: 96000
        });
        this.setData({ buttonText: '停止录音' });
      }).catch(() => {
        wx.showToast({ title: '录音权限未授权', icon: 'none' });
      });
    }
  },
  
  // 上传识别并提取
  uploadAndRecognizeRecording() {
    if (!this.data.recordFilePath) {
      wx.showToast({ title: '请先录制录音', icon: 'none' });
      return;
    }
    const filePath = this.data.recordFilePath;
    // 调用后端识别接口
    http.asr(filePath).then(res =>{
      console.log("语音识别成功，文本如下：")
      console.log(res);
      // 根据返回的文本信息，提取其中的信息
      this.setData({ editableContent: res });
      // 调用后端的提取接口
      const postData = { "text": res };
      http.ckExtract(postData).then(res =>{
        // 处理提取后的结果
        console.log("提取后的结果，如下：")
        console.log(res)
        this.updateIdAndIndex(res.data)
      }).catch(err => {
        // 提取失败
        console.log('无法解析识别结果：', err);
        console.log('接收到的原始返回数据：', err.data);
      });
    }).catch(err =>{
      // 语音识别失败
      console.log('语音识别失败：', err);
      wx.showToast({ title: '录音识别失败', icon: 'none', duration: 2000 });
    })
  },
  
  // 获取了语音识别返回的结果后，对id和index进行更新
  updateIdAndIndex(dataFields){
    // 可以直接赋值的字段
    const fields = ["diploma_number", "graduation_date", "work_location", "work_name", "work_start_date"]
    // 需要进行映射的字段
    // 名称和id的映射
    const idFields={
        graduation_type: 'graduation_type',
        education_level: 'education_level',
        graduation_school: 'graduation_school',
        job_category: 'job_category'
    }
    // 名称和选项映射的字段
    const arrayFields = {
      graduation_type: 'graduationTypeOptions',
      education_level: 'educationOptions',
      graduation_school: 'schoolOptions',
      job_category: 'occupationOptions'
    }
    // 根据结果给字段直接赋值
    fields.forEach(key =>{
        if(!dataFields[key].includes("未知")){
            this.setData({
                [`ck_academic_info.${key}`]:dataFields[key]
            })
        }
    })
    // 对工作信息进行赋值
    if(!dataFields["is_working"].includes("未知")){
      this.setData({
        ['ck_academic_info.is_working'] : this.data.workingOptions[parseInt(dataFields["is_working"])],
        ['workingIndex'] : parseInt(dataFields["is_working"])
      })
    }
    // 赋值后检查工作信息字段间的相关信息
    this.updateWorkingShowInfo(this.data.ck_academic_info.is_working);
    // 根据名字赋值id
    Object.entries(idFields).forEach(([key,value]) =>{
        // 通过两个字典的映射获取对应的值，查询id随后进行赋值
        if(!dataFields[key].includes("未知")){
            this.setData({
                [`ck_academic_info.${value}`]:tools.findIdByName(this.data[arrayFields[key]],dataFields[key])
            })
        }
    })
    //更新下标
    this.updateIndexById(this.data.ck_academic_info)
  },
    
});
